// $ANTLR 3.2 Sep 23, 2009 12:02:23 C:\\NCql\\NCql.Parser\\NCql.g 2009-11-04 14:19:20


using System;
using Antlr.Runtime;
using IList 		= System.Collections.IList;
using ArrayList 	= System.Collections.ArrayList;
using Stack 		= Antlr.Runtime.Collections.StackList;


public class NCqlLexer : Lexer {
    public const int PREFIX = 10;
    public const int T__29 = 29;
    public const int T__28 = 28;
    public const int T__27 = 27;
    public const int T__26 = 26;
    public const int PREFIXASSIGNMENTS = 18;
    public const int T__25 = 25;
    public const int T__24 = 24;
    public const int T__23 = 23;
    public const int T__22 = 22;
    public const int T__21 = 21;
    public const int NULL = 12;
    public const int T__20 = 20;
    public const int STRINGCHAR = 6;
    public const int SORTEDQUERY = 14;
    public const int EOF = -1;
    public const int MODIFIER = 17;
    public const int T__30 = 30;
    public const int MODIFIERLIST = 16;
    public const int T__31 = 31;
    public const int SERVERCHOICE = 13;
    public const int T__32 = 32;
    public const int T__33 = 33;
    public const int ESCAPESEQUENCE = 9;
    public const int SEARCHCLAUSE = 11;
    public const int SORTCRITERIA = 19;
    public const int EQUAL = 7;
    public const int UNICODECHAR = 8;
    public const int CHARSTRING1 = 4;
    public const int CHARSTRING2 = 5;
    public const int SINGLESPEC = 15;

    // delegates
    // delegators

    public NCqlLexer() 
    {
		InitializeCyclicDFAs();
    }
    public NCqlLexer(ICharStream input)
		: this(input, null) {
    }
    public NCqlLexer(ICharStream input, RecognizerSharedState state)
		: base(input, state) {
		InitializeCyclicDFAs(); 

    }
    
    override public string GrammarFileName
    {
    	get { return "C:\\NCql\\NCql.Parser\\NCql.g";} 
    }

    // $ANTLR start "T__20"
    public void mT__20() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T__20;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\NCql\\NCql.Parser\\NCql.g:7:7: ( 'sortby' )
            // C:\\NCql\\NCql.Parser\\NCql.g:7:9: 'sortby'
            {
            	Match("sortby"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T__20"

    // $ANTLR start "T__21"
    public void mT__21() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T__21;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\NCql\\NCql.Parser\\NCql.g:8:7: ( '>' )
            // C:\\NCql\\NCql.Parser\\NCql.g:8:9: '>'
            {
            	Match('>'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T__21"

    // $ANTLR start "T__22"
    public void mT__22() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T__22;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\NCql\\NCql.Parser\\NCql.g:9:7: ( 'and' )
            // C:\\NCql\\NCql.Parser\\NCql.g:9:9: 'and'
            {
            	Match("and"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T__22"

    // $ANTLR start "T__23"
    public void mT__23() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T__23;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\NCql\\NCql.Parser\\NCql.g:10:7: ( 'or' )
            // C:\\NCql\\NCql.Parser\\NCql.g:10:9: 'or'
            {
            	Match("or"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T__23"

    // $ANTLR start "T__24"
    public void mT__24() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T__24;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\NCql\\NCql.Parser\\NCql.g:11:7: ( 'not' )
            // C:\\NCql\\NCql.Parser\\NCql.g:11:9: 'not'
            {
            	Match("not"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T__24"

    // $ANTLR start "T__25"
    public void mT__25() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T__25;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\NCql\\NCql.Parser\\NCql.g:12:7: ( 'prox' )
            // C:\\NCql\\NCql.Parser\\NCql.g:12:9: 'prox'
            {
            	Match("prox"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T__25"

    // $ANTLR start "T__26"
    public void mT__26() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T__26;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\NCql\\NCql.Parser\\NCql.g:13:7: ( '(' )
            // C:\\NCql\\NCql.Parser\\NCql.g:13:9: '('
            {
            	Match('('); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T__26"

    // $ANTLR start "T__27"
    public void mT__27() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T__27;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\NCql\\NCql.Parser\\NCql.g:14:7: ( ')' )
            // C:\\NCql\\NCql.Parser\\NCql.g:14:9: ')'
            {
            	Match(')'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T__27"

    // $ANTLR start "T__28"
    public void mT__28() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T__28;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\NCql\\NCql.Parser\\NCql.g:15:7: ( '<' )
            // C:\\NCql\\NCql.Parser\\NCql.g:15:9: '<'
            {
            	Match('<'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T__28"

    // $ANTLR start "T__29"
    public void mT__29() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T__29;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\NCql\\NCql.Parser\\NCql.g:16:7: ( '>=' )
            // C:\\NCql\\NCql.Parser\\NCql.g:16:9: '>='
            {
            	Match(">="); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T__29"

    // $ANTLR start "T__30"
    public void mT__30() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T__30;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\NCql\\NCql.Parser\\NCql.g:17:7: ( '<=' )
            // C:\\NCql\\NCql.Parser\\NCql.g:17:9: '<='
            {
            	Match("<="); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T__30"

    // $ANTLR start "T__31"
    public void mT__31() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T__31;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\NCql\\NCql.Parser\\NCql.g:18:7: ( '<>' )
            // C:\\NCql\\NCql.Parser\\NCql.g:18:9: '<>'
            {
            	Match("<>"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T__31"

    // $ANTLR start "T__32"
    public void mT__32() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T__32;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\NCql\\NCql.Parser\\NCql.g:19:7: ( '==' )
            // C:\\NCql\\NCql.Parser\\NCql.g:19:9: '=='
            {
            	Match("=="); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T__32"

    // $ANTLR start "T__33"
    public void mT__33() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T__33;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\NCql\\NCql.Parser\\NCql.g:20:7: ( '/' )
            // C:\\NCql\\NCql.Parser\\NCql.g:20:9: '/'
            {
            	Match('/'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T__33"

    // $ANTLR start "CHARSTRING1"
    public void mCHARSTRING1() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = CHARSTRING1;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\NCql\\NCql.Parser\\NCql.g:133:12: ( (~ ( ' ' | '\\r' | '\\t' | '\\u000C' | '\\n' | '(' | ')' | '=' | '<' | '>' | '\"' | '/' ) )+ )
            // C:\\NCql\\NCql.Parser\\NCql.g:134:2: (~ ( ' ' | '\\r' | '\\t' | '\\u000C' | '\\n' | '(' | ')' | '=' | '<' | '>' | '\"' | '/' ) )+
            {
            	// C:\\NCql\\NCql.Parser\\NCql.g:134:2: (~ ( ' ' | '\\r' | '\\t' | '\\u000C' | '\\n' | '(' | ')' | '=' | '<' | '>' | '\"' | '/' ) )+
            	int cnt1 = 0;
            	do 
            	{
            	    int alt1 = 2;
            	    int LA1_0 = input.LA(1);

            	    if ( ((LA1_0 >= '\u0000' && LA1_0 <= '\b') || LA1_0 == '\u000B' || (LA1_0 >= '\u000E' && LA1_0 <= '\u001F') || LA1_0 == '!' || (LA1_0 >= '#' && LA1_0 <= '\'') || (LA1_0 >= '*' && LA1_0 <= '.') || (LA1_0 >= '0' && LA1_0 <= ';') || (LA1_0 >= '?' && LA1_0 <= '\uFFFF')) )
            	    {
            	        alt1 = 1;
            	    }


            	    switch (alt1) 
            		{
            			case 1 :
            			    // C:\\NCql\\NCql.Parser\\NCql.g:134:3: ~ ( ' ' | '\\r' | '\\t' | '\\u000C' | '\\n' | '(' | ')' | '=' | '<' | '>' | '\"' | '/' )
            			    {
            			    	if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '\b') || input.LA(1) == '\u000B' || (input.LA(1) >= '\u000E' && input.LA(1) <= '\u001F') || input.LA(1) == '!' || (input.LA(1) >= '#' && input.LA(1) <= '\'') || (input.LA(1) >= '*' && input.LA(1) <= '.') || (input.LA(1) >= '0' && input.LA(1) <= ';') || (input.LA(1) >= '?' && input.LA(1) <= '\uFFFF') ) 
            			    	{
            			    	    input.Consume();

            			    	}
            			    	else 
            			    	{
            			    	    MismatchedSetException mse = new MismatchedSetException(null,input);
            			    	    Recover(mse);
            			    	    throw mse;}


            			    }
            			    break;

            			default:
            			    if ( cnt1 >= 1 ) goto loop1;
            		            EarlyExitException eee1 =
            		                new EarlyExitException(1, input);
            		            throw eee1;
            	    }
            	    cnt1++;
            	} while (true);

            	loop1:
            		;	// Stops C# compiler whining that label 'loop1' has no statements


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "CHARSTRING1"

    // $ANTLR start "CHARSTRING2"
    public void mCHARSTRING2() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = CHARSTRING2;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\NCql\\NCql.Parser\\NCql.g:138:12: ( '\"' ( STRINGCHAR )* '\"' )
            // C:\\NCql\\NCql.Parser\\NCql.g:139:2: '\"' ( STRINGCHAR )* '\"'
            {
            	Match('\"'); 
            	// C:\\NCql\\NCql.Parser\\NCql.g:139:6: ( STRINGCHAR )*
            	do 
            	{
            	    int alt2 = 2;
            	    int LA2_0 = input.LA(1);

            	    if ( ((LA2_0 >= '\u0000' && LA2_0 <= '!') || (LA2_0 >= '#' && LA2_0 <= '\uFFFF')) )
            	    {
            	        alt2 = 1;
            	    }


            	    switch (alt2) 
            		{
            			case 1 :
            			    // C:\\NCql\\NCql.Parser\\NCql.g:139:6: STRINGCHAR
            			    {
            			    	mSTRINGCHAR(); 

            			    }
            			    break;

            			default:
            			    goto loop2;
            	    }
            	} while (true);

            	loop2:
            		;	// Stops C# compiler whining that label 'loop2' has no statements

            	Match('\"'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "CHARSTRING2"

    // $ANTLR start "EQUAL"
    public void mEQUAL() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = EQUAL;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\NCql\\NCql.Parser\\NCql.g:142:2: ( '=' )
            // C:\\NCql\\NCql.Parser\\NCql.g:142:4: '='
            {
            	Match('='); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "EQUAL"

    // $ANTLR start "STRINGCHAR"
    public void mSTRINGCHAR() // throws RecognitionException [2]
    {
    		try
    		{
            // C:\\NCql\\NCql.Parser\\NCql.g:144:20: ( UNICODECHAR | ESCAPESEQUENCE )
            int alt3 = 2;
            int LA3_0 = input.LA(1);

            if ( ((LA3_0 >= '\u0000' && LA3_0 <= '!') || (LA3_0 >= '#' && LA3_0 <= '[') || (LA3_0 >= ']' && LA3_0 <= '\uFFFF')) )
            {
                alt3 = 1;
            }
            else if ( (LA3_0 == '\\') )
            {
                alt3 = 2;
            }
            else 
            {
                NoViableAltException nvae_d3s0 =
                    new NoViableAltException("", 3, 0, input);

                throw nvae_d3s0;
            }
            switch (alt3) 
            {
                case 1 :
                    // C:\\NCql\\NCql.Parser\\NCql.g:145:2: UNICODECHAR
                    {
                    	mUNICODECHAR(); 

                    }
                    break;
                case 2 :
                    // C:\\NCql\\NCql.Parser\\NCql.g:146:2: ESCAPESEQUENCE
                    {
                    	mESCAPESEQUENCE(); 

                    }
                    break;

            }
        }
        finally 
    	{
        }
    }
    // $ANTLR end "STRINGCHAR"

    // $ANTLR start "UNICODECHAR"
    public void mUNICODECHAR() // throws RecognitionException [2]
    {
    		try
    		{
            // C:\\NCql\\NCql.Parser\\NCql.g:148:21: (~ ( '\"' | '\\\\' ) )
            // C:\\NCql\\NCql.Parser\\NCql.g:149:2: ~ ( '\"' | '\\\\' )
            {
            	if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '!') || (input.LA(1) >= '#' && input.LA(1) <= '[') || (input.LA(1) >= ']' && input.LA(1) <= '\uFFFF') ) 
            	{
            	    input.Consume();

            	}
            	else 
            	{
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    Recover(mse);
            	    throw mse;}


            }

        }
        finally 
    	{
        }
    }
    // $ANTLR end "UNICODECHAR"

    // $ANTLR start "ESCAPESEQUENCE"
    public void mESCAPESEQUENCE() // throws RecognitionException [2]
    {
    		try
    		{
            // C:\\NCql\\NCql.Parser\\NCql.g:151:24: ( '\\\\\\\"' )
            // C:\\NCql\\NCql.Parser\\NCql.g:152:2: '\\\\\\\"'
            {
            	Match("\\\""); 


            }

        }
        finally 
    	{
        }
    }
    // $ANTLR end "ESCAPESEQUENCE"

    // $ANTLR start "PREFIX"
    public void mPREFIX() // throws RecognitionException [2]
    {
    		try
    		{
            // C:\\NCql\\NCql.Parser\\NCql.g:154:16: ()
            // C:\\NCql\\NCql.Parser\\NCql.g:154:17: 
            {
            }

        }
        finally 
    	{
        }
    }
    // $ANTLR end "PREFIX"

    // $ANTLR start "SEARCHCLAUSE"
    public void mSEARCHCLAUSE() // throws RecognitionException [2]
    {
    		try
    		{
            // C:\\NCql\\NCql.Parser\\NCql.g:155:22: ()
            // C:\\NCql\\NCql.Parser\\NCql.g:155:23: 
            {
            }

        }
        finally 
    	{
        }
    }
    // $ANTLR end "SEARCHCLAUSE"

    // $ANTLR start "NULL"
    public void mNULL() // throws RecognitionException [2]
    {
    		try
    		{
            // C:\\NCql\\NCql.Parser\\NCql.g:156:14: ()
            // C:\\NCql\\NCql.Parser\\NCql.g:156:15: 
            {
            }

        }
        finally 
    	{
        }
    }
    // $ANTLR end "NULL"

    // $ANTLR start "SERVERCHOICE"
    public void mSERVERCHOICE() // throws RecognitionException [2]
    {
    		try
    		{
            // C:\\NCql\\NCql.Parser\\NCql.g:157:22: ()
            // C:\\NCql\\NCql.Parser\\NCql.g:157:23: 
            {
            }

        }
        finally 
    	{
        }
    }
    // $ANTLR end "SERVERCHOICE"

    // $ANTLR start "SORTEDQUERY"
    public void mSORTEDQUERY() // throws RecognitionException [2]
    {
    		try
    		{
            // C:\\NCql\\NCql.Parser\\NCql.g:158:21: ()
            // C:\\NCql\\NCql.Parser\\NCql.g:158:22: 
            {
            }

        }
        finally 
    	{
        }
    }
    // $ANTLR end "SORTEDQUERY"

    // $ANTLR start "SINGLESPEC"
    public void mSINGLESPEC() // throws RecognitionException [2]
    {
    		try
    		{
            // C:\\NCql\\NCql.Parser\\NCql.g:159:20: ()
            // C:\\NCql\\NCql.Parser\\NCql.g:159:21: 
            {
            }

        }
        finally 
    	{
        }
    }
    // $ANTLR end "SINGLESPEC"

    // $ANTLR start "MODIFIERLIST"
    public void mMODIFIERLIST() // throws RecognitionException [2]
    {
    		try
    		{
            // C:\\NCql\\NCql.Parser\\NCql.g:160:22: ()
            // C:\\NCql\\NCql.Parser\\NCql.g:160:23: 
            {
            }

        }
        finally 
    	{
        }
    }
    // $ANTLR end "MODIFIERLIST"

    // $ANTLR start "MODIFIER"
    public void mMODIFIER() // throws RecognitionException [2]
    {
    		try
    		{
            // C:\\NCql\\NCql.Parser\\NCql.g:161:18: ()
            // C:\\NCql\\NCql.Parser\\NCql.g:161:19: 
            {
            }

        }
        finally 
    	{
        }
    }
    // $ANTLR end "MODIFIER"

    // $ANTLR start "PREFIXASSIGNMENTS"
    public void mPREFIXASSIGNMENTS() // throws RecognitionException [2]
    {
    		try
    		{
            // C:\\NCql\\NCql.Parser\\NCql.g:163:2: ()
            // C:\\NCql\\NCql.Parser\\NCql.g:163:4: 
            {
            }

        }
        finally 
    	{
        }
    }
    // $ANTLR end "PREFIXASSIGNMENTS"

    // $ANTLR start "SORTCRITERIA"
    public void mSORTCRITERIA() // throws RecognitionException [2]
    {
    		try
    		{
            // C:\\NCql\\NCql.Parser\\NCql.g:164:22: ()
            // C:\\NCql\\NCql.Parser\\NCql.g:164:23: 
            {
            }

        }
        finally 
    	{
        }
    }
    // $ANTLR end "SORTCRITERIA"

    override public void mTokens() // throws RecognitionException 
    {
        // C:\\NCql\\NCql.Parser\\NCql.g:1:8: ( T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | CHARSTRING1 | CHARSTRING2 | EQUAL )
        int alt4 = 17;
        alt4 = dfa4.Predict(input);
        switch (alt4) 
        {
            case 1 :
                // C:\\NCql\\NCql.Parser\\NCql.g:1:10: T__20
                {
                	mT__20(); 

                }
                break;
            case 2 :
                // C:\\NCql\\NCql.Parser\\NCql.g:1:16: T__21
                {
                	mT__21(); 

                }
                break;
            case 3 :
                // C:\\NCql\\NCql.Parser\\NCql.g:1:22: T__22
                {
                	mT__22(); 

                }
                break;
            case 4 :
                // C:\\NCql\\NCql.Parser\\NCql.g:1:28: T__23
                {
                	mT__23(); 

                }
                break;
            case 5 :
                // C:\\NCql\\NCql.Parser\\NCql.g:1:34: T__24
                {
                	mT__24(); 

                }
                break;
            case 6 :
                // C:\\NCql\\NCql.Parser\\NCql.g:1:40: T__25
                {
                	mT__25(); 

                }
                break;
            case 7 :
                // C:\\NCql\\NCql.Parser\\NCql.g:1:46: T__26
                {
                	mT__26(); 

                }
                break;
            case 8 :
                // C:\\NCql\\NCql.Parser\\NCql.g:1:52: T__27
                {
                	mT__27(); 

                }
                break;
            case 9 :
                // C:\\NCql\\NCql.Parser\\NCql.g:1:58: T__28
                {
                	mT__28(); 

                }
                break;
            case 10 :
                // C:\\NCql\\NCql.Parser\\NCql.g:1:64: T__29
                {
                	mT__29(); 

                }
                break;
            case 11 :
                // C:\\NCql\\NCql.Parser\\NCql.g:1:70: T__30
                {
                	mT__30(); 

                }
                break;
            case 12 :
                // C:\\NCql\\NCql.Parser\\NCql.g:1:76: T__31
                {
                	mT__31(); 

                }
                break;
            case 13 :
                // C:\\NCql\\NCql.Parser\\NCql.g:1:82: T__32
                {
                	mT__32(); 

                }
                break;
            case 14 :
                // C:\\NCql\\NCql.Parser\\NCql.g:1:88: T__33
                {
                	mT__33(); 

                }
                break;
            case 15 :
                // C:\\NCql\\NCql.Parser\\NCql.g:1:94: CHARSTRING1
                {
                	mCHARSTRING1(); 

                }
                break;
            case 16 :
                // C:\\NCql\\NCql.Parser\\NCql.g:1:106: CHARSTRING2
                {
                	mCHARSTRING2(); 

                }
                break;
            case 17 :
                // C:\\NCql\\NCql.Parser\\NCql.g:1:118: EQUAL
                {
                	mEQUAL(); 

                }
                break;

        }

    }


    protected DFA4 dfa4;
	private void InitializeCyclicDFAs()
	{
	    this.dfa4 = new DFA4(this);
	    this.dfa4.specialStateTransitionHandler = new DFA.SpecialStateTransitionHandler(DFA4_SpecialStateTransition);
	}

    const string DFA4_eotS =
        "\x01\uffff\x01\x0c\x01\x10\x04\x0c\x02\uffff\x01\x17\x01\x19\x03"+
        "\uffff\x01\x0c\x02\uffff\x01\x0c\x01\x1c\x02\x0c\x05\uffff\x01\x0c"+
        "\x01\x20\x01\uffff\x01\x21\x02\x0c\x02\uffff\x01\x24\x01\x0c\x01"+
        "\uffff\x01\x26\x01\uffff";
    const string DFA4_eofS =
        "\x27\uffff";
    const string DFA4_minS =
        "\x01\x00\x01\x6f\x01\x3d\x01\x6e\x01\x72\x01\x6f\x01\x72\x02\uffff"+
        "\x02\x3d\x03\uffff\x01\x72\x02\uffff\x01\x64\x01\x00\x01\x74\x01"+
        "\x6f\x05\uffff\x01\x74\x01\x00\x01\uffff\x01\x00\x01\x78\x01\x62"+
        "\x02\uffff\x01\x00\x01\x79\x01\uffff\x01\x00\x01\uffff";
    const string DFA4_maxS =
        "\x01\uffff\x01\x6f\x01\x3d\x01\x6e\x01\x72\x01\x6f\x01\x72\x02"+
        "\uffff\x01\x3e\x01\x3d\x03\uffff\x01\x72\x02\uffff\x01\x64\x01\uffff"+
        "\x01\x74\x01\x6f\x05\uffff\x01\x74\x01\uffff\x01\uffff\x01\uffff"+
        "\x01\x78\x01\x62\x02\uffff\x01\uffff\x01\x79\x01\uffff\x01\uffff"+
        "\x01\uffff";
    const string DFA4_acceptS =
        "\x07\uffff\x01\x07\x01\x08\x02\uffff\x01\x0e\x01\x0f\x01\x10\x01"+
        "\uffff\x01\x0a\x01\x02\x04\uffff\x01\x0b\x01\x0c\x01\x09\x01\x0d"+
        "\x01\x11\x02\uffff\x01\x04\x03\uffff\x01\x03\x01\x05\x02\uffff\x01"+
        "\x06\x01\uffff\x01\x01";
    const string DFA4_specialS =
        "\x01\x02\x11\uffff\x01\x04\x08\uffff\x01\x03\x01\uffff\x01\x05"+
        "\x04\uffff\x01\x01\x02\uffff\x01\x00\x01\uffff}>";
    static readonly string[] DFA4_transitionS = {
            "\x09\x0c\x02\uffff\x01\x0c\x02\uffff\x12\x0c\x01\uffff\x01"+
            "\x0c\x01\x0d\x05\x0c\x01\x07\x01\x08\x05\x0c\x01\x0b\x0c\x0c"+
            "\x01\x09\x01\x0a\x01\x02\x22\x0c\x01\x03\x0c\x0c\x01\x05\x01"+
            "\x04\x01\x06\x02\x0c\x01\x01\uff8c\x0c",
            "\x01\x0e",
            "\x01\x0f",
            "\x01\x11",
            "\x01\x12",
            "\x01\x13",
            "\x01\x14",
            "",
            "",
            "\x01\x15\x01\x16",
            "\x01\x18",
            "",
            "",
            "",
            "\x01\x1a",
            "",
            "",
            "\x01\x1b",
            "\x09\x0c\x02\uffff\x01\x0c\x02\uffff\x12\x0c\x01\uffff\x01"+
            "\x0c\x01\uffff\x05\x0c\x02\uffff\x05\x0c\x01\uffff\x0c\x0c\x03"+
            "\uffff\uffc1\x0c",
            "\x01\x1d",
            "\x01\x1e",
            "",
            "",
            "",
            "",
            "",
            "\x01\x1f",
            "\x09\x0c\x02\uffff\x01\x0c\x02\uffff\x12\x0c\x01\uffff\x01"+
            "\x0c\x01\uffff\x05\x0c\x02\uffff\x05\x0c\x01\uffff\x0c\x0c\x03"+
            "\uffff\uffc1\x0c",
            "",
            "\x09\x0c\x02\uffff\x01\x0c\x02\uffff\x12\x0c\x01\uffff\x01"+
            "\x0c\x01\uffff\x05\x0c\x02\uffff\x05\x0c\x01\uffff\x0c\x0c\x03"+
            "\uffff\uffc1\x0c",
            "\x01\x22",
            "\x01\x23",
            "",
            "",
            "\x09\x0c\x02\uffff\x01\x0c\x02\uffff\x12\x0c\x01\uffff\x01"+
            "\x0c\x01\uffff\x05\x0c\x02\uffff\x05\x0c\x01\uffff\x0c\x0c\x03"+
            "\uffff\uffc1\x0c",
            "\x01\x25",
            "",
            "\x09\x0c\x02\uffff\x01\x0c\x02\uffff\x12\x0c\x01\uffff\x01"+
            "\x0c\x01\uffff\x05\x0c\x02\uffff\x05\x0c\x01\uffff\x0c\x0c\x03"+
            "\uffff\uffc1\x0c",
            ""
    };

    static readonly short[] DFA4_eot = DFA.UnpackEncodedString(DFA4_eotS);
    static readonly short[] DFA4_eof = DFA.UnpackEncodedString(DFA4_eofS);
    static readonly char[] DFA4_min = DFA.UnpackEncodedStringToUnsignedChars(DFA4_minS);
    static readonly char[] DFA4_max = DFA.UnpackEncodedStringToUnsignedChars(DFA4_maxS);
    static readonly short[] DFA4_accept = DFA.UnpackEncodedString(DFA4_acceptS);
    static readonly short[] DFA4_special = DFA.UnpackEncodedString(DFA4_specialS);
    static readonly short[][] DFA4_transition = DFA.UnpackEncodedStringArray(DFA4_transitionS);

    protected class DFA4 : DFA
    {
        public DFA4(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 4;
            this.eot = DFA4_eot;
            this.eof = DFA4_eof;
            this.min = DFA4_min;
            this.max = DFA4_max;
            this.accept = DFA4_accept;
            this.special = DFA4_special;
            this.transition = DFA4_transition;

        }

        override public string Description
        {
            get { return "1:1: Tokens : ( T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | CHARSTRING1 | CHARSTRING2 | EQUAL );"; }
        }

    }


    protected internal int DFA4_SpecialStateTransition(DFA dfa, int s, IIntStream _input) //throws NoViableAltException
    {
            IIntStream input = _input;
    	int _s = s;
        switch ( s )
        {
               	case 0 : 
                   	int LA4_37 = input.LA(1);

                   	s = -1;
                   	if ( ((LA4_37 >= '\u0000' && LA4_37 <= '\b') || LA4_37 == '\u000B' || (LA4_37 >= '\u000E' && LA4_37 <= '\u001F') || LA4_37 == '!' || (LA4_37 >= '#' && LA4_37 <= '\'') || (LA4_37 >= '*' && LA4_37 <= '.') || (LA4_37 >= '0' && LA4_37 <= ';') || (LA4_37 >= '?' && LA4_37 <= '\uFFFF')) ) { s = 12; }

                   	else s = 38;

                   	if ( s >= 0 ) return s;
                   	break;
               	case 1 : 
                   	int LA4_34 = input.LA(1);

                   	s = -1;
                   	if ( ((LA4_34 >= '\u0000' && LA4_34 <= '\b') || LA4_34 == '\u000B' || (LA4_34 >= '\u000E' && LA4_34 <= '\u001F') || LA4_34 == '!' || (LA4_34 >= '#' && LA4_34 <= '\'') || (LA4_34 >= '*' && LA4_34 <= '.') || (LA4_34 >= '0' && LA4_34 <= ';') || (LA4_34 >= '?' && LA4_34 <= '\uFFFF')) ) { s = 12; }

                   	else s = 36;

                   	if ( s >= 0 ) return s;
                   	break;
               	case 2 : 
                   	int LA4_0 = input.LA(1);

                   	s = -1;
                   	if ( (LA4_0 == 's') ) { s = 1; }

                   	else if ( (LA4_0 == '>') ) { s = 2; }

                   	else if ( (LA4_0 == 'a') ) { s = 3; }

                   	else if ( (LA4_0 == 'o') ) { s = 4; }

                   	else if ( (LA4_0 == 'n') ) { s = 5; }

                   	else if ( (LA4_0 == 'p') ) { s = 6; }

                   	else if ( (LA4_0 == '(') ) { s = 7; }

                   	else if ( (LA4_0 == ')') ) { s = 8; }

                   	else if ( (LA4_0 == '<') ) { s = 9; }

                   	else if ( (LA4_0 == '=') ) { s = 10; }

                   	else if ( (LA4_0 == '/') ) { s = 11; }

                   	else if ( ((LA4_0 >= '\u0000' && LA4_0 <= '\b') || LA4_0 == '\u000B' || (LA4_0 >= '\u000E' && LA4_0 <= '\u001F') || LA4_0 == '!' || (LA4_0 >= '#' && LA4_0 <= '\'') || (LA4_0 >= '*' && LA4_0 <= '.') || (LA4_0 >= '0' && LA4_0 <= ';') || (LA4_0 >= '?' && LA4_0 <= '`') || (LA4_0 >= 'b' && LA4_0 <= 'm') || (LA4_0 >= 'q' && LA4_0 <= 'r') || (LA4_0 >= 't' && LA4_0 <= '\uFFFF')) ) { s = 12; }

                   	else if ( (LA4_0 == '\"') ) { s = 13; }

                   	if ( s >= 0 ) return s;
                   	break;
               	case 3 : 
                   	int LA4_27 = input.LA(1);

                   	s = -1;
                   	if ( ((LA4_27 >= '\u0000' && LA4_27 <= '\b') || LA4_27 == '\u000B' || (LA4_27 >= '\u000E' && LA4_27 <= '\u001F') || LA4_27 == '!' || (LA4_27 >= '#' && LA4_27 <= '\'') || (LA4_27 >= '*' && LA4_27 <= '.') || (LA4_27 >= '0' && LA4_27 <= ';') || (LA4_27 >= '?' && LA4_27 <= '\uFFFF')) ) { s = 12; }

                   	else s = 32;

                   	if ( s >= 0 ) return s;
                   	break;
               	case 4 : 
                   	int LA4_18 = input.LA(1);

                   	s = -1;
                   	if ( ((LA4_18 >= '\u0000' && LA4_18 <= '\b') || LA4_18 == '\u000B' || (LA4_18 >= '\u000E' && LA4_18 <= '\u001F') || LA4_18 == '!' || (LA4_18 >= '#' && LA4_18 <= '\'') || (LA4_18 >= '*' && LA4_18 <= '.') || (LA4_18 >= '0' && LA4_18 <= ';') || (LA4_18 >= '?' && LA4_18 <= '\uFFFF')) ) { s = 12; }

                   	else s = 28;

                   	if ( s >= 0 ) return s;
                   	break;
               	case 5 : 
                   	int LA4_29 = input.LA(1);

                   	s = -1;
                   	if ( ((LA4_29 >= '\u0000' && LA4_29 <= '\b') || LA4_29 == '\u000B' || (LA4_29 >= '\u000E' && LA4_29 <= '\u001F') || LA4_29 == '!' || (LA4_29 >= '#' && LA4_29 <= '\'') || (LA4_29 >= '*' && LA4_29 <= '.') || (LA4_29 >= '0' && LA4_29 <= ';') || (LA4_29 >= '?' && LA4_29 <= '\uFFFF')) ) { s = 12; }

                   	else s = 33;

                   	if ( s >= 0 ) return s;
                   	break;
        }
        NoViableAltException nvae4 =
            new NoViableAltException(dfa.Description, 4, _s, input);
        dfa.Error(nvae4);
        throw nvae4;
    }
 
    
}
